/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package desarrollosoft.ghce.servicio.implementaciones;

import desarrollosoft.ghce.dao.interfaces.IAntecedenteHeredoFamiliarDAO;
import desarrollosoft.ghce.dao.interfaces.IAntecedenteNoPatologicoDAO;
import desarrollosoft.ghce.dao.interfaces.IAntecedentePatologicoDAO;
import desarrollosoft.ghce.dao.interfaces.IAspectoDAO;
import desarrollosoft.ghce.dao.interfaces.IGravedadDAO;
import desarrollosoft.ghce.entidades.AntecedenteHeredoFamiliar;
import desarrollosoft.ghce.entidades.AntecedenteNoPatologico;
import desarrollosoft.ghce.entidades.AntecedentePatologico;
import desarrollosoft.ghce.entidades.Aspecto;
import desarrollosoft.ghce.entidades.Gravedad;
import desarrollosoft.ghce.entidades.Paciente;
import desarrollosoft.ghce.servicio.interfaces.IServicioAntecedentes;
import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 *
 * @author ariel
 */
@Service("servicioAntecedentes")
public class ServicioAntecedentes implements IServicioAntecedentes {

    @Autowired
    @Qualifier("antecedentePatologicoDAO")
    private IAntecedentePatologicoDAO antecedentePatologicoDAO;
    
    @Autowired
    @Qualifier("gravedadDAO")
    private IGravedadDAO gravedadDAO;
    
    @Autowired
    @Qualifier("antecedenteNoPatologicoDAO")
    private IAntecedenteNoPatologicoDAO antecedenteNoPatologicoDAO;
    
    @Autowired
    @Qualifier("aspectoDAO")
    private IAspectoDAO aspectoDAO;
    
    @Autowired
    @Qualifier("antecedenteHeredoFamiliarDAO")
    private IAntecedenteHeredoFamiliarDAO antecedenteHeredoFamiliarDAO;
    
    @Override
    public List<AntecedentePatologico> obtenerTodosAntecedentesPatologicos(Paciente paciente, Gravedad gravedad) {
        return antecedentePatologicoDAO.obtenerTodosAntecedentesPatologicos(paciente, gravedad);
    }

    @Override
    public List<AntecedentePatologico> obtenerAntecedentesPatologicos(Paciente paciente, String textoBuscar, Gravedad gravedad) {
        return antecedentePatologicoDAO.obtenerAntecedentesPatologicos(paciente, textoBuscar, gravedad);
    }

    @Override
    @Transactional
    public void crearAntecedentePatologico(AntecedentePatologico antecedente) throws Exception {
        validarFechaInicio(antecedente);
        antecedentePatologicoDAO.crearAntecedentePatologico(antecedente);
    }

    @Override
    @Transactional
    public void modificarAntecedentePatologico(AntecedentePatologico antecedente) throws Exception {
        validarFechaInicio(antecedente);
        antecedentePatologicoDAO.modificarAntecedentePatologico(antecedente);
    }

    @Override
    public List<Gravedad> obtenerTodasGravedades() {
        return gravedadDAO.obtenerTodasGravedades();
    }

    @Override
    public List<AntecedenteNoPatologico> obtenerAntecedentesNoPatologicos(Paciente paciente) {
        return antecedenteNoPatologicoDAO.obtenerAntecedentesNoPatologicos(paciente);
    }

    @Override
    public List<Aspecto> obtenerTodosAspectos() {
        return aspectoDAO.obtenerTodosAspectos();
    }

    @Override
    public List<AntecedenteNoPatologico> obtenerAntecedentesNoPatologicos(Paciente paciente, Aspecto aspecto) {
        return antecedenteNoPatologicoDAO.obtenerAntecedentesNoPatologicos(paciente, aspecto);
    }

    @Override
    @Transactional
    public void crearAntecedenteNoPatologico(AntecedenteNoPatologico antecedente) {
        antecedenteNoPatologicoDAO.crearAntecedenteNoPatologico(antecedente);
    }

    @Override
    @Transactional
    public void modificarAntecedenteNoPatologico(AntecedenteNoPatologico antecedente) {
        antecedenteNoPatologicoDAO.modificarAntecedenteNoPatologico(antecedente);
    }

    @Override
    public List<Aspecto> obtenerAspectosCoincidentes(Paciente paciente, Aspecto aspecto) {
        return aspectoDAO.obtenerAspectosCoincidentes(paciente, aspecto);
    }

    @Override
    public boolean loTieneCargado(Paciente paciente, Aspecto aspecto) {
        return aspectoDAO.loTieneCargado(paciente, aspecto);
    }

    @Override
    public List<AntecedenteHeredoFamiliar> obtenerAntecedentesHeredoFamiliares(Paciente paciente) {
        return antecedenteHeredoFamiliarDAO.obtenerAntecedentesHeredoFamiliares(paciente);
    }

    @Override
    public List<AntecedenteHeredoFamiliar> obtenerAntecedentesHeredoFamiliares(Paciente paciente, String textoBuscar) {
        return antecedenteHeredoFamiliarDAO.obtenerAntecedentesHeredoFamiliares(paciente, textoBuscar);
    }

    @Override
    @Transactional
    public void crearAntecedenteHeredoFamiliar(AntecedenteHeredoFamiliar antecedente) throws Exception {
        antecedenteHeredoFamiliarDAO.crearAntecedenteHeredoFamiliar(antecedente);
    }

    @Override
    @Transactional
    public void modificarAntecedenteHeredoFamiliar(AntecedenteHeredoFamiliar antecedente) throws Exception {
        antecedenteHeredoFamiliarDAO.modificarAntecedenteHeredoFamiliar(antecedente);
    }

    @Override
    @Transactional
    public void eliminarAntecedentePatologico(AntecedentePatologico antecedente) throws Exception {
        antecedentePatologicoDAO.eliminarAntecedentePatologico(antecedente);
    }

    @Override
    @Transactional
    public void eliminarAntecedenteNoPatologico(AntecedenteNoPatologico antecedenteNoPatologico) throws Exception {
        antecedenteNoPatologicoDAO.eliminarAntecedenteNoPatologico(antecedenteNoPatologico);
    }

    @Override
    @Transactional
    public void eliminarAntecedenteHeredoFamiliar(AntecedenteHeredoFamiliar antecedenteHeredoFamiliar) throws Exception {
        antecedenteHeredoFamiliarDAO.eliminarAntecedenteHeredoFamiliar(antecedenteHeredoFamiliar);
    }

    private void validarFechaInicio(AntecedentePatologico antecedente) throws Exception {
        Date fechaNacimiento = antecedente.getPaciente().getFechaNacimiento();
        Date fechaAntecedente = antecedente.getFecha();
        if (fechaNacimiento == null || fechaAntecedente == null) {
            return;
        }
        if (fechaAntecedente.before(fechaNacimiento)) {
            throw new Exception("La fecha de inicio no puede ser anterior a la fecha de nacimiento del paciente");
        }
        Date fechaFin = antecedente.getFechaFin();
        if (fechaFin != null && fechaFin.before(fechaAntecedente)) {
            throw new Exception("La fecha de fin no puede ser anterior a la fecha de inicio");
        }
    }
    
}
